<!--  -->
<template>
  <div class="">
    1、实现函数柯里化
    2、以下数据结构中，id 代表部门编号，name 是部门名称，parentId 是父部门编
    号，为 0 代表一级部门，现在要求实现一个 convert 方法，把原始 list 转换
    成树形结构，parentId 为多少就挂载在该 id 的属性 children 数组下，结构如
    下
  </div>
</template>

<script setup lang="ts">
import { forEach } from 'lodash-es';
import {} from 'vue';
const list =[
  {id:1, name:'部门 A', parentId:0},
  {id:2, name:'部门 B', parentId:0},
  {id:3, name:'部门 C', parentId:1},
  {id:4, name:'部门 D', parentId:1},
  {id:5, name:'部门 E', parentId:2},
  {id:6, name:'部门 F', parentId:3},
  {id:7, name:'部门 G', parentId:2},
  {id:8, name:'部门 H', parentId:4},
  {id:9, name:'部门 O', parentId:8}];

function convert(list) {
  // 创建一个哈希表，用于快速查找每个部门的信息
  const map = {};

  // 遍历原始列表，将每个部门存入哈希表
  list.forEach(item => {
    map[item.id] = { ...item, children: [] };
  });



  // 遍历原始列表，为每个部门添加其子部门
  list.forEach(item => {
    const parentId = item.parentId;

    // 如果父部门存在，则将当前部门添加到父部门的 children 数组中
    if (map[parentId]) {
      map[parentId].children.push(map[item.id]);
    }
  });
  // 从哈希表中提取所有一级部门（parentId 为 0）
  const result = list.filter(item => item.parentId === 0).map(item => map[item.id]);

  return result;
}


console.log('conver1', convert(list));

function digui(list, parentId = 0){
  const result = [];

  list.forEach((item) => {
    if(item.parentId === parentId){
      const children = digui(list, item.id);
      result.push({...item, children});
    }
  });
  return result;
}
console.log('duigui', digui(list));

const res =  convert(list);
console.log("🚀 ~ res:", res);
function flattenTree(tree) {
  const flattened = [];

  function dfs(node) {
    const { children, ...rest} = node;
    flattened.push(rest); // 将当前节点添加到扁平化列表中
    if (children) {
      node.children.forEach(dfs); // 递归处理子节点
    }
  }

  tree.forEach(dfs); // 对树中的每个根节点执行深度优先搜索

  return flattened;
}
console.log(flattenTree(res));
const promise = new Promise((resolve, reject) => {
  resolve({age:20});
});
async function test(){
  const data = await promise;
  console.log("🚀 ~ test ~ data:", data);
}
test();
function add() {
  // 缓存已经提供的参数
  const values = [].slice.call(arguments);

  // 返回一个柯里化的函数
  return function curried() {
    // 将新提供的参数添加到缓存的参数列表中
    const moreValues = [].slice.call(arguments);
    values.push.apply(values, moreValues);

    // 如果提供了所有参数，则执行求和并返回结果
    if (values.length === 4) {
      return values.reduce(function (sum, value) {
        return sum + value;
      }, 0);
    }

    // 否则继续返回柯里化的函数
    return curried;
  };
}

function random(min, max){
  const arr= [];
  for(let i = 0; i< 10; i++){
    arr.push(Math.floor(Math.random() * (max - min + 1) +  min));
  }
  arr.sort((a, b) => a -b);
  console.log("🚀 ~ random ~ numberArr:", arr);
  return arr;
}
console.log(random(10, 100));

</script>

<style lang="scss" scoped>

</style>
